home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / FNT2BDF.ZIP / fnt2bdf.cc < prev    next >
C/C++ Source or Header  |  1994-11-19  |  14KB  |  475 lines
  1. //
  2. // PROGRAM FILE:  fnt2bdf.c
  3. //
  4. // PURPOSE:    This file contains the individual methods
  5. //           that compose the fnt2bdf class.
  6. //
  7. // PROGRAMMER: Kevin Carothers
  8. //
  9. // PLACE:      Transaction Technology, Inc.
  10. //
  11.  
  12. #define MAP_BEG    118 
  13.  
  14. extern "C" {
  15. #include <stdio.h>
  16. }
  17. #include <stream.h>
  18. #include <sys/param.h>
  19. #include <sys/types.h>
  20.  
  21. #include "fnt2bdf.hh"
  22.  
  23.  
  24. CPE_FONT::CPE_FONT(char *fnt_file_name)
  25. {
  26. void usage(void);
  27. FILE   *fp;
  28. int     ic=0, done = FALSE;
  29.  
  30.     cpe_max_bytes = 0;    // member data member initialization
  31.     strcpy(cpe_filename, fnt_file_name);
  32.  
  33.     if(strcmp(cpe_filename, "") == 0)
  34.         usage();
  35.  
  36.     if((fp = fopen(cpe_filename, "r")) == (FILE *) 0)
  37.         usage();
  38.  
  39.     for(done=FALSE;done != TRUE; ) {
  40.         file_buffer[cpe_max_bytes] = (unsigned char) getc(fp);
  41.         if (!feof(fp) && cpe_max_bytes < BUFMAX)
  42.             cpe_max_bytes++;
  43.         else
  44.             done = TRUE;
  45.         }
  46.     fclose(fp);
  47.  
  48.     // 
  49.     // Read the file -- now set up the font pointers, etc...
  50.     //
  51.     bcopy(file_buffer, (char *) &cpe_font_struct.hdr, sizeof(struct fnt_hdrS));
  52.  
  53.     {        // set up the charWidth/charOffset  structure pairs (dfCharTable)...
  54.     int l_fchar = return_data_value(dfChar, cpe_font_struct.hdr.dfFirstChar),         //  dfFirstChar; 
  55.         l_lchar = return_data_value(dfChar, cpe_font_struct.hdr.dfLastChar);          //  dfLastChar; 
  56.  
  57.     int l_len = l_lchar-l_fchar, l_ptr = MAP_BEG;
  58.  
  59.     // malloc size = (# chars) * sizeof(WinCharS)
  60.     if((cpe_font_struct.dfCharTable = (struct WinCharS *) calloc(sizeof(struct WinCharS), l_len)) == NULL) {
  61.     printf("can't malloc room for dfCharTable\n");
  62.     exit(0);
  63.     }
  64.  
  65.     // NOW, convert them all to UNIX (lton) notation...
  66.     for(ic=0; ic < l_len; ic++) {
  67.        cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
  68.     l_ptr += 2;    // bump by sizeof(short)
  69.  
  70.  
  71.     if( return_data_value(dfShort, cpe_font_struct.hdr.dfVersion) == 0x200) {
  72.         cpe_font_struct.dfCharTable[ic].charOffset = 
  73.             return_data_value(dfShort, &file_buffer[l_ptr]);
  74.         l_ptr += 2;    // bump by sizeof(long)
  75.         }
  76.     else {     //  Windows Version 3.0 type font
  77.         cpe_font_struct.dfCharTable[ic].charOffset = 
  78.             return_data_value(dfLong, &file_buffer[l_ptr]);
  79.         l_ptr += 4;    // bump by sizeof(long)
  80.         }
  81.     }
  82.     }
  83.  
  84.    
  85. }
  86.  
  87. CPE_FONT::~CPE_FONT(void)
  88. {
  89. }
  90.  
  91. void
  92. CPE_FONT::dump_font_hdr(void)
  93. {
  94. int    ret_value;
  95.  
  96.     printf("Font Header:   \n");
  97.     printf("    dfVersion = 0x%x\n", 
  98.     return_data_value(dfShort, cpe_font_struct.hdr.dfVersion));           //  dfVersion[2];     
  99.  
  100.     printf("    dfSize = 0x%x\n", 
  101.     return_data_value(dfLong, cpe_font_struct.hdr.dfSize));            //  dfSize[4];            
  102.     printf("    dfCopyright = %s\n", 
  103.     cpe_font_struct.hdr.dfCopyright);                  //  dfCopyright[60];      
  104.  
  105.     printf("    dfType = 0x%x\n", 
  106.     return_data_value(dfShort, cpe_font_struct.hdr.dfType));            //  dfType[2];
  107.  
  108.     printf("    dfPoints = 0x%x\n", 
  109.     return_data_value(dfShort, cpe_font_struct.hdr.dfPoints));            //  dfPoints[2];
  110.  
  111.     printf("    dfVertRes = 0x%x\n", 
  112.     return_data_value(dfShort, cpe_font_struct.hdr.dfVertRes));            //  dfVertRes[2]
  113.  
  114.     printf("    dfHorizRes = 0x%x\n", 
  115.     return_data_value(dfShort, cpe_font_struct.hdr.dfHorizRes));        //  dfHorizRes[2]
  116.  
  117.     printf("    dfAscent = 0x%x\n", 
  118.     return_data_value(dfShort, cpe_font_struct.hdr.dfAscent));            //  dfAscent[2];
  119.  
  120.     printf("    dfInternalLeading = 0x%x\n", 
  121.     return_data_value(dfShort, cpe_font_struct.hdr.dfInternalLeading));   //  dfInternalLeading
  122.  
  123.     printf("    dfExternalLeading = 0x%x\n", 
  124.     return_data_value(dfShort, cpe_font_struct.hdr.dfExternalLeading));   //  dfExternalLeading[2]; 
  125.  
  126.     printf("    dfItalic = 0x%x\n", 
  127.     return_data_value(dfChar, cpe_font_struct.hdr.dfItalic));            //  dfItalic
  128.  
  129.     printf("    dfUnderline = 0x%x\n", 
  130.     return_data_value(dfChar, cpe_font_struct.hdr.dfUnderline));       //  dfUnderline;
  131.  
  132.     printf("    dfStrikeOut = 0x%x\n", 
  133.     return_data_value(dfChar, cpe_font_struct.hdr.dfStrikeOut));       //  dfStrikeOut;
  134.  
  135.     printf("    dfWeight = 0x%x\n", 
  136.     return_data_value(dfShort, cpe_font_struct.hdr.dfWeight));            //  dfWeight[2]; 
  137.  
  138.     printf("    dfCharSet = 0x%x\n", 
  139.     return_data_value(dfChar, cpe_font_struct.hdr.dfCharSet));            //  dfCharSet; 
  140.  
  141.     printf("    dfPixWidth = 0x%x\n", 
  142.     return_data_value(dfShort, cpe_font_struct.hdr.dfPixWidth));        //  dfPixWidth[2]
  143.  
  144.     printf("    dfPixHeight = 0x%x\n", 
  145.     return_data_value(dfShort, cpe_font_struct.hdr.dfPixHeight));      //  dfPixHeight[2]
  146.  
  147.     printf("    dfPitchAndFamily = 0x%x\n", 
  148.     return_data_value(dfChar, cpe_font_struct.hdr.dfPitchAndFamily)); //  dfPitchAndFamily
  149.  
  150.     printf("    dfAvgWidth = 0x%x\n", 
  151.     return_data_value(dfShort, cpe_font_struct.hdr.dfAvgWidth));        //  dfAvgWidth[2];
  152.  
  153.     printf("    dfMaxWidth = 0x%x\n", 
  154.     return_data_value(dfShort, cpe_font_struct.hdr.dfMaxWidth));           //  dfMaxWidth[2];
  155.  
  156.     printf("    dfFirstChar = 0x%x\n", 
  157.     return_data_value(dfChar, cpe_font_struct.hdr.dfFirstChar));       //  dfFirstChar;
  158.  
  159.     printf("    dfLastChar = 0x%x\n", 
  160.     return_data_value(dfChar, cpe_font_struct.hdr.dfLastChar));            //  dfLastChar;
  161.  
  162.     printf("    dfDefaultChar = 0x%x\n", 
  163.     return_data_value(dfChar, cpe_font_struct.hdr.dfDefaultChar));   //  dfDefaultChar;
  164.  
  165.     printf("    dfBreakChar = 0x%x\n", 
  166.     return_data_value(dfChar, cpe_font_struct.hdr.dfBreakChar));       //  dfBreakChar; 
  167.  
  168.     printf("    dfWidthBytes = 0x%x\n", 
  169.     return_data_value(dfShort, cpe_font_struct.hdr.dfWidthBytes));    //  dfWidthBytes[2];
  170.  
  171.     printf("    dfDevice = 0x%x\n", 
  172.     return_data_value(dfLong, cpe_font_struct.hdr.dfDevice));            //  dfDevice[4];
  173.  
  174.     printf("    dfFace = 0x%x\n", 
  175.     return_data_value(dfLong, cpe_font_struct.hdr.dfFace));   //  dfFace[4];
  176.  
  177.     printf("    dfBitsPointer = 0x%x\n", 
  178.     return_data_value(dfLong, cpe_font_struct.hdr.dfBitsPointer)); //  dfBitsPointer[4];
  179.  
  180.     printf("    dfBitsOffset = 0x%x\n", 
  181.     return_data_value(dfLong, cpe_font_struct.hdr.dfBitsOffset));    //  dfBitsOffset[4];
  182.  
  183.     // Not Used: printf("    dfReserved = 0x%x\n", 
  184.     // Not Used:     return_data_value(dfChar, cpe_font_struct.hdr.dfReserved));            //  dfReserved;
  185.  
  186.     // Not Used: printf("    dfFlags = 0x%x\n", 
  187.     // Not Used: return_data_value(dfLong, cpe_font_struct.hdr.dfFlags));            //  dfFlags[4];
  188.  
  189.     // Not Used: printf("    dfAspace = 0x%x\n", 
  190.     // Not Used: return_data_value(dfShort, cpe_font_struct.hdr.dfAspace));            //  dfAspace[2];
  191.  
  192.     // Not Used: printf("    dfBspace = 0x%x\n", 
  193.     // Not Used: return_data_value(dfShort, cpe_font_struct.hdr.dfBspace));            //  dfBspace[2];
  194.  
  195.     // Not Used: printf("    dfCspace = 0x%x\n", 
  196.     // Not Used: return_data_value(dfShort, cpe_font_struct.hdr.dfCspace));            //  dfCspace[2];
  197.  
  198.     // Not Used: printf("    dfColorTable = 0x%x\n", 
  199.     // Not Used: return_data_value(dfShort, cpe_font_struct.hdr.dfColorTable));    //  dfColorTable[4];
  200.  
  201.     // Not Used: printf("    dfReserved1 = 0x%x\n", 
  202.     // Not Used: return_data_value(dfLong, cpe_font_struct.hdr.dfReserved1));    //  dfReserved1[0][4];
  203.  
  204. }
  205.  
  206. void
  207. CPE_FONT::dump_font_bitmaps(void)
  208. {
  209. int    ic, l_tot, ret_value;
  210.     int l_fchar = return_data_value(dfChar, cpe_font_struct.hdr.dfFirstChar), //  dfFirstChar; 
  211.         l_lchar = return_data_value(dfChar, cpe_font_struct.hdr.dfLastChar);  //  dfLastChar; 
  212.  
  213.     int l_len = l_lchar-l_fchar, 
  214.     l_ptr = MAP_BEG,
  215.     l_hgt = return_data_value(dfChar, cpe_font_struct.hdr.dfPixHeight); 
  216.  
  217.     // first, adjust l_len for unmapped chars, and last char...
  218.     // NOW, convert them all to UNIX (lton) notation...
  219.     for(ic=0; ic < l_len; ic++) {
  220.     int rowidx, l_span,        // how many char-cols wide is char?
  221.         l_idx = cpe_font_struct.dfCharTable[ic].charOffset;
  222.  
  223.     if(cpe_font_struct.dfCharTable[ic].charWidth == 0) {
  224.         printf("\nChar 0x%x  is Unmapped...\n\n", ic);
  225.         l_fchar++;    // Go to next one
  226.         continue;
  227.         }
  228.  
  229.     l_span = (int) (cpe_font_struct.dfCharTable[ic].charWidth-1)/8; 
  230.  
  231.     printf("\n\nChar = 0x%x   (\"0x%x\")\n", ic, l_fchar);
  232.  
  233.     for(rowidx=0; rowidx < l_hgt; rowidx++) {
  234.         switch(l_span) {
  235.         case(0):    // 1-7 pixels wide font
  236.             {
  237.             printf("%s\n", dotdash(file_buffer[l_idx+rowidx]));
  238.             break;
  239.             }
  240.         
  241.         case(1):    // 8-15 pixels wide font
  242.             {
  243.             printf("%s", dotdash(file_buffer[l_idx+rowidx]));
  244.             printf("%s", dotdash(file_buffer[l_idx+l_hgt+rowidx]));
  245.             printf("\n");
  246.             break;
  247.             }
  248.  
  249.         case(2):    // 16-23 pixels wide font
  250.             {
  251.             printf("%s", dotdash(file_buffer[l_idx+rowidx]));
  252.             printf("%s", dotdash(file_buffer[l_idx+l_hgt+rowidx]));
  253.             printf("%s", dotdash(file_buffer[l_idx+(2*l_hgt)+rowidx]));
  254.             printf("\n");
  255.             break;
  256.             }
  257.  
  258.         case(3):    // 24-31 pixels wide font
  259.             {
  260.             printf("%s", dotdash(file_buffer[l_idx+rowidx]));
  261.             printf("%s", dotdash(file_buffer[l_idx+l_hgt+rowidx]));
  262.             printf("%s", dotdash(file_buffer[l_idx+(2*l_hgt)+rowidx]));
  263.             printf("%s", dotdash(file_buffer[l_idx+(3*l_hgt)+rowidx]));
  264.             printf("\n");
  265.             break;
  266.             }
  267.  
  268.         default:
  269.             printf("Character  0x%x is TOO WIDE (%d)!\n", ic, cpe_font_struct.dfCharTable[ic].charWidth);
  270.             break;
  271.         }
  272.         }
  273.     l_fchar++;    // Go to next one
  274.     }
  275. }
  276.  
  277.  
  278. void
  279. CPE_FONT::dump_bdf(void)
  280. {
  281. int    ic, ret_value;
  282. int     l_fchar = return_data_value(dfChar, cpe_font_struct.hdr.dfFirstChar), //  dfFirstChar; 
  283.         l_lchar = return_data_value(dfChar, cpe_font_struct.hdr.dfLastChar);  //  dfLastChar; 
  284.  
  285. int     l_len = l_lchar-l_fchar, 
  286.         l_ptr = MAP_BEG,
  287.         l_hgt = return_data_value(dfChar, cpe_font_struct.hdr.dfPixHeight); 
  288. FILE   *fp;
  289. char    l_filename[256];
  290.  
  291.     make_bdf_filename(l_filename);    // this is the name we'll use for our output file
  292.  
  293.     if((fp = fopen(l_filename, "w")) == (FILE *) 0)   {
  294.     printf("Couldn't open \"%s\" for output. Bye...\n", l_filename);
  295.     exit(-1);
  296.     }
  297.  
  298.     dump_bdf_hdr();    // Write the header (up to the 1st STARTCHAR cmd)
  299.  
  300.     // NOW, convert all chars to UNIX (lton) notation...
  301.     for(ic=0; ic < l_len; ic++) {
  302.     int rowidx, l_span,        // how many char-cols wide is char?
  303.         l_idx = cpe_font_struct.dfCharTable[ic].charOffset;
  304.  
  305.     l_span = (int) (cpe_font_struct.dfCharTable[ic].charWidth-1)/8; 
  306.  
  307.     printf("STARTCHAR %d  \n", ic);
  308.     printf("ENCODING %d\n",   l_fchar);
  309.     printf("SWIDTH    %d    %d \n", 
  310.         cpe_font_struct.dfCharTable[ic].charWidth*1000, 
  311.         l_hgt*1000);
  312.  
  313.     printf("DWIDTH    %d    %d \n", 
  314.         cpe_font_struct.dfCharTable[ic].charWidth, l_hgt);
  315.  
  316.     printf("BBX  %d  %d  %d   %d\n",
  317.         cpe_font_struct.dfCharTable[ic].charWidth, l_hgt, 0, 0);
  318.  
  319.     printf("BITMAP\n");
  320.     for(rowidx=0; rowidx < l_hgt; rowidx++) {
  321.         switch(l_span) {
  322.         case(0):    // 1-7 pixels wide font
  323.             {
  324.             printf("%02X\n", (int) file_buffer[l_idx+rowidx]);
  325.             break;
  326.             }
  327.         
  328.         case(1):    // 8-15 pixels wide font
  329.             {
  330.             printf("%02X%02X", 
  331.             (int) file_buffer[l_idx+rowidx], file_buffer[l_idx+l_hgt+rowidx]);
  332.             printf("\n");
  333.             break;
  334.             }
  335.  
  336.         case(2):    // 16-23 pixels wide font
  337.             {
  338.             printf("%02X%02X%02X", 
  339.             file_buffer[l_idx+rowidx],
  340.                 file_buffer[l_idx+l_hgt+rowidx],
  341.                 file_buffer[l_idx+(2*l_hgt)+rowidx]);
  342.             printf("\n");
  343.             break;
  344.             }
  345.  
  346.         case(3):    // 24-31 pixels wide font
  347.             {
  348.             printf("%02X%02X%02X%02X", 
  349.             file_buffer[l_idx+rowidx],
  350.             file_buffer[l_idx+l_hgt+rowidx],
  351.             file_buffer[l_idx+(2*l_hgt)+rowidx],
  352.             file_buffer[l_idx+(3*l_hgt)+rowidx]);
  353.             printf("\n");
  354.             break;
  355.             }
  356.  
  357.         default:
  358.             printf("Character  is TOO WIDE!\n");
  359.             break;
  360.         }
  361.         }
  362.     printf("ENDCHAR\n");
  363.  
  364.     l_fchar++;    // Go to next one
  365.     }
  366. printf("ENDFONT\n");
  367. }
  368.  
  369.  
  370. int
  371. CPE_FONT::return_data_value(enum data_types dtype, unsigned char * pChr)
  372. {
  373. int   ret_val = 0;
  374.  
  375.     switch(dtype) {
  376.     case (dfChar): {
  377.         ret_val = (int) pChr[0];
  378.         break;
  379.         }
  380.     case(dfShort): {
  381.         ret_val = 0;
  382.         ret_val = pChr[0];
  383.         ret_val += (pChr[1] << 8);       // ms byte
  384.         break;
  385.         }
  386.     case(dfLong): {
  387.         int  i;
  388.         ret_val = 0;
  389.  
  390.         for(i=3; i >= 0; i--)  {
  391.         ret_val += pChr[i] << (8*i);
  392.         }
  393.         break;
  394.         }
  395.     }  /* End CASE */
  396.  
  397.     return ret_val;
  398. }
  399.  
  400.  
  401.  
  402. char *
  403. CPE_FONT::dotdash(char iChr)
  404. {
  405.     static char   sBuf[128];
  406.     unsigned char lmask = (unsigned char) 0x01;
  407.     int i, j;
  408.  
  409.     sBuf[8] = '\0';    // null-terminate
  410.  
  411.     for(i=7; i >= 0; i--) {
  412.     sBuf[i] =  (iChr & lmask) ? '*' : '.';
  413.     lmask <<= 1;
  414.     }
  415.  
  416.     return sBuf;
  417. }
  418.  
  419.  
  420.  
  421. void
  422. CPE_FONT::make_bdf_filename(char   *lP)
  423. {
  424. void  usage(void);
  425. char  l_tmp[256],
  426.      *l_index;
  427.  
  428.     if(strlen(cpe_filename) == 0)
  429.     usage();
  430.  
  431.     strcpy(l_tmp, cpe_filename);    // start building the file name
  432.     l_index = index(l_tmp, '.');
  433.  
  434.     if( l_index != (char *) 0)
  435.     strcpy(l_tmp, ".bdf");    // append new extension
  436.     else
  437.     strncat(l_tmp, ".bdf", 4);    // append to end of filename
  438.  
  439.     strcpy(lP, l_tmp);
  440. }
  441.  
  442.  
  443.  
  444.  
  445. void
  446. CPE_FONT::dump_bdf_hdr(void)
  447. {
  448. int     l_fchar = return_data_value(dfChar, cpe_font_struct.hdr.dfFirstChar), //  dfFirstChar; 
  449.         l_lchar = return_data_value(dfChar, cpe_font_struct.hdr.dfLastChar);  //  dfLastChar; 
  450. int     l_len = l_lchar-l_fchar;
  451.  
  452.     printf("STARTFONT   2.1\n");
  453.  
  454.     printf("FONT XXX\n");
  455.     printf("SIZE  %d  %d   %d\n",  
  456.     return_data_value(dfShort, cpe_font_struct.hdr.dfPixHeight),
  457.     return_data_value(dfShort, cpe_font_struct.hdr.dfHorizRes),
  458.     return_data_value(dfShort, cpe_font_struct.hdr.dfVertRes));            //  dfVertRes[2]
  459.  
  460.     printf("FONTBOUNDINGBOX %d  %d  %d  %d\n",
  461.     return_data_value(dfShort, cpe_font_struct.hdr.dfMaxWidth),
  462.         return_data_value(dfChar, cpe_font_struct.hdr.dfPixHeight),
  463.        0, 0);
  464.  
  465.     printf("STARTPROPERTIES  1\n");
  466.  
  467.     printf("FONT_ASCENT %d\n",  
  468.     return_data_value(dfShort, cpe_font_struct.hdr.dfAscent));            //  dfAscent[2];
  469.  
  470.     printf("ENDPROPERTIES\n");
  471.  
  472.     printf("CHARS  %d\n",  l_len);
  473.     return;
  474. }
  475.